home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / hc.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-26  |  16.6 KB  |  645 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                 ATKeyboard Hilfedateiencompiler               ** */
  4. /* **            Copright (C) 1992-1993 by Thomas Dreibholz         ** */
  5. /* **                      All rights reserved                      ** */
  6. /* **                                                               ** */
  7. /* ******************************************************************* */
  8.  
  9. #include <exec/types.h>
  10. #include <exec/memory.h>
  11. #include <libraries/dos.h>
  12.  
  13. #define MAXSIZE(x) ((1000*5*22)+x)+1000000L
  14.  
  15. #define PAGE_INDEX 1
  16. #define PAGE_TEXT  2
  17.  
  18. ULONG x,y,z;
  19. UWORD i,j,k,zeile,a,b,t;
  20. UBYTE style,fp,bp;
  21. WORD  cmd,page;
  22. UBYTE chr;
  23. ULONG offset;
  24. UWORD length;
  25. UBYTE s[500];
  26. UBYTE byte;
  27. UWORD wort;
  28. ULONG langwort;
  29. BOOL  insert=FALSE;
  30.  
  31. UBYTE             *name;
  32. struct FileHandle *in,*out;
  33. UWORD              GoTo[100];
  34. UWORD              GoGad[100];
  35. UBYTE              GoPic[100];
  36. UWORD              GoToCnt;
  37. UWORD              GoGadCnt;
  38. UBYTE              GoPicCnt;
  39. UWORD              DefaultCnt;
  40. UWORD              Default[32];
  41. UBYTE              Buffer[2048];
  42. ULONG              Offset[1000];
  43. ULONG              MOffset[1000];
  44. ULONG              POffset[1000];
  45. ULONG              TOffset[1000];
  46. ULONG              GOffset[1000];
  47. ULONG              PNOffset[1000];
  48. UWORD              Length[1000];
  49. UBYTE              Flags[1000];
  50. UBYTE              mem[250];
  51. UBYTE             *InBuf,*OutBuf;
  52. ULONG              BufferSize;
  53. ULONG              IPos,OPos,IMax;
  54. BOOL               MainIndex;
  55.  
  56.  
  57. VOID Out(m,len)
  58.  UBYTE *m;
  59.  ULONG  len;
  60. {
  61.  REGISTER ULONG i,j;
  62.  
  63.  for(i=0;i<len;i++)
  64.   {
  65.    OutBuf[OPos]=m[i];
  66.    OPos++;
  67.   }
  68. }
  69.  
  70. VOID WriteStyles()
  71. {
  72.  sprintf(&mem,"\x9b%d;%d;%dm",style,fp,bp);
  73.  i=strlen(&mem);
  74.  Out(&mem,i);
  75.  offset+=i;
  76.  length+=i;
  77. }
  78.  
  79. ULONG Get(m,len)
  80.  UBYTE *m;
  81.  ULONG  len;
  82. {
  83.  REGISTER ULONG i,j,x;
  84.  
  85.  x=0;
  86.  for(i=0;((i<len) && (IPos<=IMax));i++)
  87.   {
  88.    m[i]=InBuf[IPos];
  89.    IPos++; x++;
  90.   }
  91.  return(x);
  92. } 
  93.  
  94.  
  95. VOID Stop(num)
  96.  UWORD num;
  97. {
  98.  
  99.  Close(in);
  100.  Close(out);
  101.  DeleteFile(name);
  102.  FreeMem(InBuf,BufferSize);
  103.  switch(num)
  104.   {
  105.    case 1:
  106.      printf("Zeile %ld: #endpage für nicht vorhandene Seite.\n",zeile);
  107.     break;
  108.    case 2:
  109.      printf("Zeile %ld: #endpage erwartet.\n",zeile);
  110.     break;
  111.    case 3:
  112.      printf("Zeile %ld: #goto/#gpic/#gad steht auf keiner Seite.\n",zeile);
  113.     break;
  114.    case 4:
  115.      printf("Zeile %ld: Seitennummerangabe fehlerhaft.\n",zeile);
  116.     break;
  117.    case 5:
  118.      printf("Zeile %ld: Unbekannter Befehl.\n",zeile);
  119.     break;
  120.    case 6:
  121.      printf("Zeile %ld: #space steht auf keiner Seite.\n",zeile);
  122.     break;
  123.    case 7:
  124.      printf("Zeile %ld: Seitentext ohne Seitenangabe durch #page/#index.\n",zeile);
  125.     break;
  126.    case 8:
  127.      printf("Zeile %ld: Ungültige Bildnummer bei #gpic/picture.\n",zeile);
  128.     break;
  129.    case 20:
  130.      printf("Zeile %ld: #picture darf auf keiner Seite stehen.\n",zeile);
  131.     break;
  132.    case 30:
  133.      printf("Zeile %ld: Bild kann nicht geladen werden!\n",zeile);
  134.     break;
  135.    case 40:
  136.      printf("Zeile %ld: Seitennummerangabe bei #default fehlerhaft.\n",zeile);
  137.     break;
  138.   }
  139.  exit(0);
  140. }
  141.  
  142.  
  143. VOID main(argc,argv)
  144.  LONG argc;
  145.  UBYTE *argv[];
  146. {
  147.  struct FileHandle *fh;
  148.  
  149.  printf("\nATUtilities Online-Hilfe Hilfstextcompiler - Version 2.0  25. 11. 1993\n");
  150.  printf("Copyright (C) 1993 by Thomas Dreibholz. All rights reserved.\n");
  151.  printf("----------------------------------------------------------------------\n");
  152.  if(argc<3)
  153.   {
  154.    printf("Aufruf: %s [Quelltext] [Hilfedatei].\n",argv[0]);
  155.    exit(0);
  156.   }
  157.  if(argc>3)
  158.   {
  159.    if(!(strcmp(argv[3],"+I"))) insert=TRUE;
  160.   }
  161.  
  162.  MainIndex=FALSE;
  163.  name=argv[2];
  164.  in=Open(argv[1],MODE_OLDFILE);
  165.  if(in!=NULL)
  166.   {
  167.    Seek(in,0,OFFSET_END);
  168.    IMax=Seek(in,0,OFFSET_BEGINNING);
  169.    BufferSize=IMax+MAXSIZE(IMax);
  170.    InBuf=AllocMem(BufferSize,MEMF_CLEAR|MEMF_PUBLIC);
  171.    if(InBuf!=NULL)
  172.     {
  173.      OutBuf=(UBYTE *)((ULONG)InBuf+IMax);
  174.      IPos=0; OPos=0;
  175.      out=Open(argv[2],MODE_NEWFILE);
  176.      if(out!=NULL)
  177.       {
  178.        printf("Lese Quelltext ...\n");
  179.        Read(in,InBuf,IMax);
  180.        cmd=-1;
  181.        page=-1;
  182.        zeile=0;
  183.        style=0; fp=33; bp=40;
  184.        Out("HELP_2.0",8);
  185.        offset=8;
  186.        printf("Compiliere Quelltext ...\n");
  187.        j=Get(&mem,1);
  188.        chr=mem[0];
  189.  
  190.        while(j!=0)
  191.         {
  192.          if(chr=='#')
  193.           {
  194.            k=0; j=Get(&mem,1);
  195.            while((mem[k]!=10)&&(k<249)&&(j==1))
  196.             {
  197.              k++; j=Get(&mem[k],1);
  198.             }
  199.            mem[k]=0x00;
  200.            zeile++;
  201.            if(j!=0)
  202.             {
  203.  
  204.              if(!(strncmp(&mem,"rem",3)))
  205.               {
  206.                /* Kommentarzeile */
  207.               }
  208.  
  209.              else if(!(strncmp(&mem,"default",7)))
  210.               {
  211.                for(i=0;i<30;i++) Default[i]=0;
  212.                i=8;
  213.                DefaultCnt=0;
  214.                while(i<strlen(&mem))
  215.                 {
  216.                  if((mem[i]>='0')&&(mem[i]<='9'))
  217.                   {
  218.                    k=atol(&mem[i]);
  219.                    i+=4;
  220.                    if(k>999) Stop(40);
  221.                    Default[DefaultCnt]=k; DefaultCnt++;
  222.                   }
  223.                  else
  224.                   {
  225.                    i+=2;
  226.                    Default[DefaultCnt]=2000; DefaultCnt++;
  227.                   }
  228.                 }
  229.               }
  230.  
  231.              else if(!(strncmp(&mem,"endpage",7)))
  232.               {
  233.                style=0; fp=33; bp=40;
  234.                if(page!=-1)
  235.                 {
  236.                  if(GoToCnt>0)
  237.                   {
  238.                    MOffset[page]=offset;
  239.                    for(i=0;i<GoToCnt;i++)
  240.                     {
  241.                      Out(&GoTo[i],2L); offset+=2;
  242.                     }
  243.                    if(DefaultCnt>0)
  244.                     {
  245.                      wort=2000;
  246.                      Out(&wort,2L); offset+=2;
  247.                     }
  248.                   }
  249.                  if(DefaultCnt>0)
  250.                   {
  251.                    if(MOffset[page]==0) MOffset[page]=offset;
  252.                    for(i=0;i<DefaultCnt;i++)
  253.                     {
  254.                      if(Default[i]!=page)
  255.                       {
  256.                        Out(&Default[i],2L); t=Default[i]; offset+=2;
  257.                       }
  258.                      else
  259.                       {
  260.                        if((i>0)&&(Default[i-1]==2000)&&(Default[i+1]==2000))
  261.                         {
  262.                          OPos-=2; offset-=2;
  263.                         }
  264.                        else if((i==0)&&(i<Default-1)&&(Default[i+1]==2000))
  265.                         {
  266.                          i++;
  267.                         }
  268.                       }
  269.                     }
  270.                    if(t==2000)
  271.                     {
  272.                      OPos-=2; offset-=2;
  273.                     }
  274.                   }
  275.                  if(MOffset[page]!=0)
  276.                   {
  277.                    wort=0xFFFF;
  278.                    Out(&wort,2L); offset+=2;
  279.                   }
  280.                  if(GoGadCnt>0)
  281.                   {
  282.                    GOffset[page]=offset;
  283.                    wort=0xFFFF;
  284.                    for(i=0;i<GoGadCnt;i++)
  285.                     {
  286.                      Out(&GoGad[i],2L); offset+=2;
  287.                     }
  288.                    Out(&wort,2L); offset+=2;
  289.                   }
  290.                  if(GoPicCnt>0)
  291.                   {
  292.                    POffset[page]=offset;
  293.                    for(i=0;i<GoPicCnt;i++)
  294.                     {
  295.                      Out(&GoPic[i],1L); offset++;
  296.                     }
  297.                    byte=0xFF;
  298.                    Out(&byte,1L); offset++;
  299.                   }
  300.                  Length[page]=length;
  301.                  GoToCnt=0;
  302.                  GoPicCnt=0;
  303.                  GoGadCnt=0;
  304.                 }
  305.                else Stop(1);
  306.                cmd=-1; page=-1;
  307.               }
  308.  
  309.              else if(!(strncmp(&mem,"page",4)))
  310.               {
  311.                if(page!=-1)
  312.                 {
  313.                  Stop(2);
  314.                 }
  315.                page=atol(&mem[5]);
  316.                if(page>999) Stop(4);
  317.                if(page==0)
  318.                 {
  319.                  MainIndex=TRUE;
  320.                  printf("Info:  Soll Seite 000 keine Indexseite sein?\n");
  321.                 }
  322.                cmd=1;
  323.                Offset[page]=offset;
  324.                MOffset[page]=0;
  325.                TOffset[page]=0;
  326.                Length[page]=0;
  327.                Flags[page]=PAGE_TEXT;
  328.                a=9; b=0;
  329.                while((mem[a]>25)&&(b<290))
  330.                 {
  331.                  s[b]=mem[a]; a++; b++;
  332.                 }
  333.                s[b]=0x00;
  334.                k=strlen(&s)+1;
  335.                offset+=k;
  336.                Out(&s,k);
  337.                length=0;
  338.               }
  339.  
  340.              else if(!(strncmp(&mem,"picture",7)))
  341.               {
  342.                if(page!=-1)
  343.                 {
  344.                  Stop(20);
  345.                 }
  346.                page=atol(&mem[8]);
  347.                if(page>99) Stop(8);
  348.                PNOffset[page]=offset;
  349.                a=11; b=0;
  350.                while((mem[a]>25)&&(b<290))
  351.                 {
  352.                  s[b]=mem[a]; a++; b++;
  353.                 }
  354.                s[b]=0x00;
  355.                if(insert==FALSE)
  356.                 {
  357.                  byte=0;
  358.                  Out(&byte,1L); offset++;
  359.                  k=strlen(&s)+1;
  360.                  offset+=k;
  361.                  Out(&s,k);
  362.                 }
  363.                else
  364.                 {
  365.                  byte=1;
  366.                  Out(&byte,1L); offset++;
  367.                  printf("Info:  Bild %02ld <%s> wird eingefügt - ",page,&s);
  368.                  fh=Open(&s,MODE_OLDFILE);
  369.                  if(fh!=NULL)
  370.                   {
  371.                    Seek(fh,0,OFFSET_END);
  372.                    z=Seek(fh,0,OFFSET_BEGINNING);
  373.                    Out(&z,4L); offset+=4;
  374.                    x=Read(fh,&Buffer,2048);
  375.                    while(x>0)
  376.                     {
  377.                      Out(&Buffer,x); offset+=x;
  378.                      x=Read(fh,&Buffer,2048);
  379.                     }
  380.                    printf("%ld KBytes.\n",z/1024);
  381.                    Close(fh);
  382.                   }
  383.                  else
  384.                   {
  385.                    Stop(30);
  386.                   }
  387.                 }
  388.                page=-1;
  389.               }
  390.  
  391.              else if(!(strncmp(&mem,"index",5)))
  392.               {
  393.                if(page!=-1)
  394.                 {
  395.                  Stop(2);
  396.                 }
  397.                page=atol(&mem[5]);
  398.                if(page==0) MainIndex=TRUE;
  399.                if(page>999) Stop(4);
  400.                cmd=1;
  401.                MOffset[page]=0;
  402.                TOffset[page]=0;
  403.                Length[page]=0;
  404.                Offset[page]=offset;
  405.                Flags[page]=PAGE_INDEX;
  406.                a=10; b=0;
  407.                while((mem[a]>25)&&(b<290))
  408.                 {
  409.                  s[b]=mem[a]; a++; b++;
  410.                 }
  411.                s[b]=0x00;
  412.                k=strlen(&s)+1;
  413.                offset+=k;
  414.                Out(&s,k);
  415.                length=0;
  416.               }
  417.  
  418.              else if(!(strncmp(&mem,"goto",4)))
  419.               {
  420.                if(page!=-1)
  421.                 {
  422.                  k=atol(&mem[5]);
  423.                  if(k>999) Stop(4);
  424.                  if(k!=page)
  425.                   {
  426.                    GoTo[GoToCnt]=k; GoToCnt++;
  427.                   }
  428.                 }
  429.                else Stop(3);
  430.               }
  431.  
  432.              else if(!(strncmp(&mem,"gad",3)))
  433.               {
  434.                if(page!=-1)
  435.                 {
  436.                  k=atol(&mem[4]);
  437.                  if(k>999) Stop(4);
  438.                  if(k!=page)
  439.                   {
  440.                    GoGad[GoGadCnt]=k; GoGadCnt++;
  441.                   }
  442.                 }
  443.                else Stop(3);
  444.               }
  445.  
  446.              else if(!(strncmp(&mem,"gpic",4)))
  447.               {
  448.                if(page!=-1)
  449.                 {
  450.                  k=atol(&mem[5]);
  451.                  if(k>99) Stop(8);
  452.                  GoPic[GoPicCnt]=k; GoPicCnt++;
  453.                 }
  454.                else Stop(3);
  455.               }
  456.  
  457.              else if(!(strncmp(&mem,"space",5)))
  458.               {
  459.                if(page!=-1)
  460.                 {
  461.                  GoTo[GoToCnt]=2000; GoToCnt++;
  462.                 }
  463.                else Stop(6);
  464.               }
  465.  
  466.              else if(!(strncmp(&mem,"gspace",6)))
  467.               {
  468.                if(page!=-1)
  469.                 {
  470.                  GoGad[GoGadCnt]=2000; GoGadCnt++;
  471.                 }
  472.                else Stop(6);
  473.               }
  474.  
  475.              else if(!(strncmp(&mem,"pspace",6)))
  476.               {
  477.                if(page!=-1)
  478.                 {
  479.                  GoPic[GoPicCnt]=200; GoPicCnt++;
  480.                 }
  481.                else Stop(6);
  482.               }
  483.  
  484.              else if(!(strncmp(&mem,"endfile",7)))
  485.               {
  486.                goto ende;
  487.               }
  488.  
  489.              else
  490.               {
  491.                Stop(5);
  492.               }
  493.             }
  494.           }
  495.          else
  496.           {
  497.            zeile++;
  498.            /* Seitentext */
  499.            if(cmd!=-1)
  500.             {
  501.              if(TOffset[page]==0) TOffset[page]=offset;
  502.              if(chr==10)
  503.               {
  504.                mem[0]=0;
  505.                Out(&mem,1); offset++; length++;
  506.               }
  507.              else
  508.               {
  509.                if(Flags[page]==PAGE_TEXT) WriteStyles();
  510.                IPos--;
  511.                j=Get(&mem,1);
  512.                while((j==1)&&(mem[0]!=10))
  513.                 {
  514.                  if((mem[0]=='`')&&(Flags[page]==PAGE_TEXT))
  515.                   {
  516.                    j=Get(&mem[1],1);
  517.                    if((j==1)&&(mem[1]!='`'))
  518.                     {
  519.                      switch(toupper(mem[1]))
  520.                       {
  521.                        case 'F':
  522.                          style=1;
  523.                         break;
  524.                        case 'K':
  525.                          style=3;
  526.                         break;
  527.                        case 'U':
  528.                          style=4;
  529.                         break;
  530.                        case 'I':
  531.                          style=7;
  532.                         break;
  533.                        case 'N':
  534.                          style=0;
  535.                         break;
  536.                        case 'R':
  537.                          style=0; fp=33; bp=40;
  538.                         break;
  539.                        default:
  540.                          if((mem[1]>='0')&&(mem[1]<='8'))
  541.                           {
  542.                            j=Get(&mem[2],1);
  543.                            if(j==1)
  544.                             {
  545.                              if((mem[2]>='0')&&(mem[2]<='8'))
  546.                               {
  547.                                fp=(mem[1]-48)+30;
  548.                                bp=(mem[2]-48)+40;
  549.                               }
  550.                             }
  551.                           }
  552.                         break;
  553.                       }
  554.                      WriteStyles();
  555.                     }
  556.                    else
  557.                     {
  558.                      if(j==1)
  559.                       {
  560.                        mem[0]='`';
  561.                        Out(&mem,1); offset++; length++;
  562.                       }
  563.                     }
  564.                   }
  565.                  else
  566.                   {
  567.                    Out(&mem,1); offset++; length++;
  568.                   }
  569.                  j=Get(&mem,1);
  570.                 }
  571.                mem[0]=0x00;
  572.                Out(&mem,1); offset++; length++;
  573.               }
  574.             }
  575.            else
  576.             {
  577.              Stop(7);
  578.             }
  579.           }
  580.          j=Get(&mem,1);
  581.          chr=mem[0];
  582.         }
  583. ende:
  584.        byte=0; langwort=offset;
  585.        for(i=0;i<1000;i++)
  586.         {
  587.          if(Offset[i]==0)
  588.           {
  589.            Out(&byte,1); offset++;
  590.           }
  591.          else
  592.           {
  593.            Out(&Flags[i],1);
  594.            Out(&Length[i],2);
  595.            Out(&Offset[i],4);
  596.            Out(&TOffset[i],4);
  597.            Out(&GOffset[i],4);
  598.            Out(&MOffset[i],4);
  599.            Out(&POffset[i],4);
  600.            offset+=1;
  601.            offset+=2;
  602.            offset+=4;
  603.            offset+=4;
  604.            offset+=4;
  605.            offset+=4;
  606.            offset+=4;
  607.           }
  608.         }
  609.        for(i=0;i<100;i++)
  610.         {
  611.          Out(&PNOffset[i],4);
  612.          offset+=4;
  613.         }
  614.        Out(&langwort,4); offset+=4;
  615.        printf("Check:  %lx  -  %lx\n",OPos,offset);
  616.        printf("Schreibe Hilfe-Datei ...\n");
  617.        langwort=Write(out,OutBuf,OPos);
  618.        Close(out);
  619.        if(langwort!=OPos)
  620.         {
  621.          printf("FEHLER! Übersetzte Hilfe-Datei kann nicht gespeichert werden!\n");
  622.          DeleteFile(argv[2]);
  623.         }
  624.        printf("Fertig.\n");
  625.       }
  626.      else
  627.       {
  628.        printf("Ausgabedatei \"%s\" konnte nicht eröffnet werden!\n",argv[2]);
  629.       }
  630.      FreeMem(InBuf,BufferSize);
  631.     }
  632.    else
  633.     {
  634.      printf("Nicht genug Speicher für Compiliervorgang!\n");
  635.     }
  636.    Close(in);
  637.   }
  638.  else
  639.   {
  640.    printf("Eingabedatei \"%s\" konnte nicht geöffnet werden!\n",argv[1]);
  641.   }
  642.  exit(0);
  643. }
  644.  
  645.